//类
//基本使用
class Car {
    //属性
    color: string | undefined

    //构造函数
    constructor(color: string | undefined) {
        this.color = color;
    }

    //一般函数
    fly(fuel: string): string {
        return this.color + ':起飞咯，使用的燃油是' + fuel;
    }
}

//创建实例
const car = new Car("红色");
//调用方法
console.log(car.fly('大饼'))


//类继承
//继承后有父类的所有方法后属性，直接调用，有super。
class Trucks extends Car {
    constructor(color: string | undefined, volume: number | undefined) {
        //将color 属性值通过super传递给父函数
        super(color);
        this.volume = volume;
    }

    volume: number | undefined

    //重写父函数方法
    fly(fuel: string): string {
        //子函数通过super调用父函数方法
        super.fly(fuel);
        return super.fly('我是子函数fly方法');
    }
}

const trucks = new Trucks('红色', 1);
console.log(trucks.fly('燃油'));


//修饰符
//修饰符默认是public
// public 公开
// private 私有
// protected。protected 修饰符与 private 修饰符的行为很相似，但有一点不同，protected成员在子类类中仍然可以访问。
class PersonOne {
    private _monicker: string | undefined

    speek(): string {
        return this._monicker + '你在bb什么';
    }


    get monicker(): string | undefined {
        return this._monicker;
    }

    set monicker(value: string | undefined) {
        this._monicker = value;
    }
}

//静态属性
// 静态属性, 是类对象的属性
// 非静态属性, 是类的实例对象的属性
class Person {
    name1: string = 'A'
    static name2: string = 'B'
}

console.log(Person.name2)
console.log(new Person().name1)


//抽象类 与抽象方法
abstract  class Animal{
    //修饰符 名称（参数列表）:返回值类型
    abstract cry():void
    // todo 静态方法是个什么意思
    static  aa():void{

    }
    run () {
        console.log('run()')
    }
}
 class  Dog extends Animal{
     cry() {

     }

 }
 const dog =new Dog();
console.log(dog.cry())
console.log(dog.run())
export {}
